package com.chapter.sample.reactor.stream;

//函数式接口: 只要是函数式接口就可以用lambda接口简化
//函数式接口：接口中有且只有一个未实现的方法，这个接口就叫函数式接口

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

interface MyInterFace {
    int sum(int i, int j);
}

@FunctionalInterface
interface MyHaha {
    int haha();

    default int heihei() {
        return 2 * 2;
    }//默认实现

    default int heihei2() {
        return 2 * 2;
    }//默认实现
}

interface MyHehe {
    int hehe(int i);
}

class MyInterFaceImpl implements MyInterFace {

    @Override
    public int sum(int i, int j) {
        return i + j;
    }
}

public class Lambda {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Alice");
        list.add("Bob");
        list.add("Charlie");
        list.add("David");

        //比较器
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println(list);

        //直接写函数式接口就很方便，(o1, o2) -> o1.compareTo(o2)
        Collections.sort(list, (o1, o2) -> o1.compareTo(o2));
        System.out.println(list);

        //类:：方法；引用类中的实例方法
        Collections.sort(list, String::compareTo);
        System.out.println(list);


        //Runnable 匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("haha");
            }
        }).start();

        new Thread(() -> System.out.println("哈哈")).start();


        //最佳实战
    }

    /**
     * @param args
     */
    public static void aaa(String[] args) {
        //1、自己创建实现类对象
        MyInterFace myInterFace = new MyInterFaceImpl();
        System.out.println(myInterFace.sum(1, 2));

        //2、创建匿名实现类
        MyInterFace myInterFace1 = new MyInterFace() {
            @Override
            public int sum(int i, int j) {
                return i * i + j * j;
            }
        };
        System.out.println(myInterFace1.sum(2, 3));
        //冗余写法

        //3、lambda表达式:语法糖，参数列表 + 箭头 + 方法体
        MyInterFace myInterFace2 = (int i, int j) -> {
            return i * i + j * j;
        };
        System.out.println(myInterFace2.sum(3, 4));

        //参数位置最少情况
        MyHaha myHaha = () -> {
            return 1;
        };
        System.out.println(myHaha.haha());


        MyHehe myHehe = y -> {
            return y + 1;
        };
        System.out.println(myHehe.hehe(7));

        //完整写法如上
        //简化写法
        //1）、参数类型可以不写，只写（参数名），参数变量名随意定义
        //      参数表最少可以只有一个（），或者只有一个参数名
        //2）、方法体如果只有一句话，{} 可以不写
        MyHehe myHehe2 = y -> y + 2;
        System.out.println(myHehe2.hehe(7));


        //总结：Lambda表达式：（参数表）-> {方法体}
    }
}
